
use std::collections::HashMap;
use regex::Regex;
use serde_json::{Map, Value};
use tracing::debug;
use tracing::field::debug;

pub struct TemplateEngine;

impl TemplateEngine {
    pub fn render(template: &str, data: &HashMap<String, Vec<Map<String, Value>>>) -> String {

        // 定义正则表达式来匹配 {{ variable }}
        let re = Regex::new(r"\{\{\s*(\w+)\s*\}\}").expect("Invalid regex pattern");

        // 替换所有匹配的变量
        // let result = re.replace_all(template, |caps: &regex::Captures| {
        //     let variable_name = caps.get(1).unwrap().as_str();
        //     data.get(variable_name).unwrap_or(&String::new()).to_string()
        // });

        // 定义正则表达式匹配 <wu-for> 标签

        let re_wu_for: Regex = Regex::new(
            r#"(?xsi)                       # 启用注释、跨行、大小写不敏感模式
                <wu-for\s+                      # 匹配开始标签名
                form-data\s*=\s*["'](.*?)["'] # 精准匹配 form-data="messages"
                [^>]*>                          # 跳过其他属性
                (.*?)                           # 非贪婪捕获内部内容
                </wu-for>                       # 结束标签
            "#
            ).expect("Invalid regex pattern for wu-for");

        // 替换所有 <wu-for> 标签
        let result = re_wu_for.replace_all(template, |caps: &regex::Captures| {
            let form_name = caps.get(1).unwrap().as_str(); // 获取 form 属性值
            let inner_template = caps.get(2).unwrap().as_str(); // 获取标签内部内容
            debug!("parse form_name: {:?}, inner_template: {:?}", form_name, inner_template);
            // 从数据源中获取列表数据
            if let Some(list_data) = data.get(form_name) {
                debug!("parse list_data: {:?}", list_data);
                // 根据列表数据生成多个 <li> 元素
                list_data.iter()
                    .map(|item| {
                        // let mut rendered_item = inner_template.to_string();
                        debug!("parse inner_template: {:?}", inner_template);
                        // for (key, value) in item {
                        //     debug!("parse key: {:?}, value: {:?}", key, value);
                        //     rendered_item = rendered_item.replace(&format!("{{{}}}", key), value.as_str().unwrap());
                        // }
                        // rendered_item

                        let result_item = re.replace_all(inner_template, |caps: &regex::Captures| {
                            let variable_name = caps.get(1).unwrap().as_str();
                            // data.get(variable_name).unwrap_or(&String::new()).to_string()


                            if let Some(value) = item.get(variable_name) {
                                println!("value: {:?}", value);
                                return value.to_string();
                            }

                            String::new()
                        });
                        result_item.to_string()
                    })
                    .collect::<Vec<_>>()
                    .join("")
            } else {
                // 如果数据不存在，返回空字符串
                String::new()
            }
        });

        // let mut result = String::new();
        // let mut index = 0;
        // debug!("parse start: index {} and template.len: {}", index, template.len());
        //
        // while index < template.len() {
        //     if let Some(start) = template[index..].find("{{") {
        //         let start_index = index + start;
        //         result.push_str(&template[index..start_index]);
        //         debug!("parse1 start_index :  {}", start_index);
        //         if let Some(end) = template[start_index + 2..].find("}}") {
        //             let end_index = start_index + 2 + end;
        //             let variable_name = template[start_index + 2..end_index].trim();
        //             debug!("parse2 end_index :  {}", end_index);
        //             if let Some(value) = data.get(variable_name) {
        //                 result.push_str(value);
        //             } else {
        //                 result.push_str(variable_name);
        //             }
        //
        //             index = end_index + 2;
        //         } else {
        //             result.push_str(&template[start_index..]);
        //             break;
        //         }
        //     } else {
        //         result.push_str(&template[index..]);
        //         break;
        //     }
        // }

        result.to_string()
        // String::new()
    }
}


#[cfg(test)]
mod tests {
    use std::collections::HashMap;
    use std::pin::pin;
    use serde_json::json;
    use tracing::info;
    // 注意这个惯用法：在 tests 模块中，从外部作用域导入所有名字。
    use super::*;

    #[test]
    fn test_template_render() {
        // let template = r#"
        //                 <li>
        //                     {{ message }}  :  {{ name }} : {{ date }}
        //                 </li>
        //                 "#;
        // // 定义正则表达式来匹配 {{ variable }}
        // let re = Regex::new(r"\{\{\s*(\w+)\s*\}\}").expect("Invalid regex pattern");
        //
        // let data_vec  = json!([
        //      {
        //          "name": "John",
        //          "message": "Hello",
        //          // "date": "2023-07-01",
        //      },
        //      {
        //          "name": "Jane",
        //          "message": "Hi",
        //          // "date": "2023-07-02",
        //      },
        // ]);
        //
        // serde_json::to_string(&data_vec).unwrap();
        //
        // let data = data_vec.as_array().unwrap();
        //
        //
        // let result = data.iter()
        //     .map(|item| {
        //         // let mut rendered_item = inner_template.to_string();
        //         // println!("parse inner_template: {:?}", template);
        //         // for (key, value) in item {
        //         //     println!("parse key: {:?}, value: {:?}", key, value);
        //         //     rendered_item = rendered_item.replace(&format!("{{{}}}", key), value.as_str().unwrap());
        //         // }
        //         let result_item = re.replace_all(template, |caps: &regex::Captures| {
        //             let variable_name = caps.get(1).unwrap().as_str();
        //             // data.get(variable_name).unwrap_or(&String::new()).to_string()
        //
        //             let item_map = item.as_object().unwrap();
        //             if let Some(value) = item_map.get(variable_name) {
        //                 println!("value: {:?}", value);
        //                 return value.to_string();
        //             }
        //
        //             String::new()
        //         });
        //         result_item.to_string()
        //     })
        //     .collect::<Vec<_>>()
        //     .join("");
        //
        //
        // println!("{}", result.to_string());
        // assert_eq!(rendered, "Hello, John! You are 30 years old.");
    }
}